In the context of the present application, functions that access an identical global variable are called interfering functions, regardless of whether in a particular case a conflict between the functions is actually possible.
A known technique for ensuring the consistency of global variables in a data processing system whenever a function accesses a global variable that could be disturbed by a coinciding access of an interfering function is to exclude all other functions from accessing the same variable. Such a method, however, is generally not suited for real-time applications since the execution of functions which must access a variable that is excluded from access must be stopped until access to the variable is again permitted, which can result in unpredictable delays in the execution of these functions.
Another known method of ensuring data consistency is to use copies of the global variable for the individual functions. That is to say, an interfering function creates at the beginning of its execution a local copy of a required global variable, subsequently works with this copy, and if the function is capable of changing the variable, then prior to its termination the local variable is copied back into the global variable, the copy processes not being interruptible by other functions.
In the case of complex program systems there is the problem that at the beginning of development it is often not clear at what points access conflicts may arise that can lead to data inconsistencies. This problem could be met by making local copies in each function of all global variables required by the function. Such a procedure, however, leads to a substantially higher requirement in memory and processing power.
At the time of system integration, a statement as to which global variables in which function require a copy is always possible since at this time all functions as well as their call frequency and priority (their right to interrupt other functions) are known. In order to facilitate system integration there exist various software tools such as OLT (offline tool) or ESCAPE (www.etas.com), which on the basis of additional information identify the functions which must work with copies for ensuring data consistency and which change these functions in such a way that instead of the original variables they work with the corresponding copies. In addition, corresponding copying processes are generated. Depending on the operating system configuration, which is static, these copying processes synchronize the copies with their original variables of one or several function(s), which may use joint copies since they do not mutually interrupt one another. Since these tools read the operating system configuration in order to ascertain the priority and grouping of the individual functions, they are also able to insert automatically the required copying processes into the operating system configuration before or after a function or function group.
The application of these tools is limited by the fact that they have to rely on changing the source code. This is not necessarily always available however. Particularly if a development partner is supplied with functions from a third party, this third party for reasons of secrecy will often provide the functions not in the form of source code, but at best as object code. Such functions cannot be processed using the known tools such that to ensure the absence of conflict extensive changes to the functions existing in the source code may be required which cannot be automated and are thus expensive and susceptible to error.
Moreover, the intervention in the source code in each case requires a recompilation of the changed code. Particularly changes in the priority of a function (e.g. operating system configuration) may entail extensive changes in the source code of a great number of other functions. In large program systems this may result in very long compile times, which may substantially slow down the development process.
Another problem is that the known development tools are in each case tailored to specific high-level languages, i.e., are not suited for processing functions written in different high-level languages to form an application.